const WebSocket = require('ws');
const http = require('http');

// 创建HTTP服务器
const server = http.createServer();

// 创建WebSocket服务器
const wss = new WebSocket.Server({ server });

// 存储连接的客户端
const clients = new Set();

console.log('WebSocket服务器启动在 ws://localhost:8080');

wss.on('connection', (ws) => {
  console.log('新客户端连接');
  clients.add(ws);
  
  // 发送欢迎消息
  ws.send(JSON.stringify({
    type: 'system',
    content: '欢迎使用WebSocket聊天服务器！'
  }));
  
  ws.on('message', (message) => {
    try {
      const data = JSON.parse(message);
      console.log('收到消息:', data);
      
      if (data.type === 'message') {
        // 模拟处理用户消息并返回多条回复
        simulateResponse(ws, data.content);
      } else if (data.type === 'request_data') {
        // 处理数据请求
        sendTableData(ws, data.content, data.sessionId);
      }
    } catch (error) {
      console.error('解析消息失败:', error);
      ws.send(JSON.stringify({
        type: 'error',
        content: '消息格式错误'
      }));
    }
  });
  
  ws.on('close', () => {
    console.log('客户端断开连接');
    clients.delete(ws);
  });
  
  ws.on('error', (error) => {
    console.error('WebSocket错误:', error);
    clients.delete(ws);
  });
});

// 模拟服务器响应函数
function simulateResponse(ws, userMessage) {
  // 根据消息内容判断消息类型和生成相应回复
  const messageAnalysis = analyzeMessage(userMessage);
  const responses = generateResponses(userMessage, messageAnalysis);
  
  console.log(`将发送 ${responses.length} 条回复`);
  
  // 逐条发送回复，模拟真实的对话场景
  responses.forEach((response, index) => {
    setTimeout(() => {
      if (ws.readyState === WebSocket.OPEN) {
        const isLast = index === responses.length - 1;
        ws.send(JSON.stringify({
          type: 'response',
          content: response.content,
          messageId: Date.now() + index,
          messageType: response.messageType, // 添加消息类型
          isLast: isLast
        }));
        console.log(`发送回复 ${index + 1}: ${response.content} [${response.messageType}]${isLast ? ' (最后一条)' : ''}`);
        
        // 如果是最后一条消息，发送完成信号
        if (isLast) {
          setTimeout(() => {
            if (ws.readyState === WebSocket.OPEN) {
              ws.send(JSON.stringify({
                type: 'complete',
                content: '所有回复已发送完成'
              }));
              console.log('发送完成信号');
            }
          }, 500);
        }
      }
    }, (index + 1) * 1000); // 每条回复间隔1秒
  });
}

// 分析消息内容，判断应该返回什么类型的回复
function analyzeMessage(message) {
  const lowerMessage = message.toLowerCase();
  
  // 操作类关键词
  const actionKeywords = ['推荐', '建议', '方案', '策略', '计划', '优化', '改进', '调整', '修改', '删除', '添加', '创建', '执行', '实施'];
  // 只读类关键词
  const readOnlyKeywords = ['查询', '显示', '展示', '分析', '统计', '报告', '数据', '信息', '状态', '结果', '详情', '说明'];
  
  const hasActionKeywords = actionKeywords.some(keyword => lowerMessage.includes(keyword));
  const hasReadOnlyKeywords = readOnlyKeywords.some(keyword => lowerMessage.includes(keyword));
  
  return {
    hasActionKeywords,
    hasReadOnlyKeywords,
    message: lowerMessage
  };
}

// 根据分析结果生成不同类型的回复
function generateResponses(userMessage, analysis) {
  const responses = [];
  
  // 总是先有一个确认收到消息的回复（只读类）
  responses.push({
    content: `我收到了您的消息: "${userMessage}"`,
    messageType: 'readonly'
  });
  
  // 根据分析结果添加不同类型的回复
  if (analysis.hasActionKeywords) {
    // 添加操作类回复
    responses.push({
      content: `基于您的需求，我建议采取以下行动方案：\n1. 分析当前情况\n2. 制定具体策略\n3. 实施改进措施`,
      messageType: 'action'
    });
    
    responses.push({
      content: `另外，我还可以为您提供以下优化建议：\n- 数据结构优化\n- 性能提升方案\n- 用户体验改进`,
      messageType: 'action'
    });
  }
  
  if (analysis.hasReadOnlyKeywords) {
    // 添加只读类回复
    responses.push({
      content: `根据您的查询，这里是相关的分析结果和数据展示。详细信息请查看右侧数据表格。`,
      messageType: 'readonly'
    });
  }
  
  // 如果没有特定关键词，添加通用回复
  if (!analysis.hasActionKeywords && !analysis.hasReadOnlyKeywords) {
    responses.push({
      content: `这是一个关于"${userMessage}"的详细回复，包含了相关的信息和分析。`,
      messageType: 'readonly'
    });
    
    // 随机添加一个操作类建议
    if (Math.random() > 0.5) {
      responses.push({
        content: `针对"${userMessage}"，我建议您可以考虑以下改进措施，请确认是否采用。`,
        messageType: 'action'
      });
    }
  }
  
  return responses;
}

// 存储会话数据的映射表
const sessionDataMap = new Map();

// 发送表格数据函数
function sendTableData(ws, requestContent, sessionId) {
  console.log('收到数据请求，发送表格数据...会话ID:', sessionId);
  
  if (ws.readyState === WebSocket.OPEN) {
    // 检查是否已有该会话的数据
    let mockTableData;
    
    if (sessionDataMap.has(sessionId)) {
      // 使用已存储的数据
      mockTableData = sessionDataMap.get(sessionId);
      console.log('使用已存储的会话数据');
    } else {
      // 为新会话生成数据
      mockTableData = [
        {
          id: '1',
          name: `会话${sessionId.slice(-4)}的分析结果1`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '2',
          name: `会话${sessionId.slice(-4)}的分析结果2`,
          value: Math.floor(Math.random() * 1000),
          category: '类别B',
          status: '异常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '3',
          name: `会话${sessionId.slice(-4)}的分析结果3`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '4',
          name: `会话${sessionId.slice(-4)}的分析结果4`,
          value: Math.floor(Math.random() * 1000),
          category: '类别C',
          status: '警告',
          date: new Date().toLocaleDateString()
        }
      ];
      
      // 存储会话数据
      sessionDataMap.set(sessionId, mockTableData);
      console.log('已生成并存储新的会话数据');
    }
    
    ws.send(JSON.stringify({
      type: 'data',
      content: mockTableData,
      sessionId: sessionId
    }));
    
    console.log('已发送表格数据:', mockTableData.length, '条');
  }
}

// 处理服务器错误
server.on('error', (error) => {
  console.error('服务器错误:', error);
});

// 启动服务器
server.listen(8080, () => {
  console.log('服务器正在监听端口 8080');
});

// 优雅关闭
process.on('SIGINT', () => {
  console.log('\n正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(ws => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.close();
    }
  });
  
  // 关闭服务器
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
});

process.on('SIGTERM', () => {
  console.log('\n收到SIGTERM信号，正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(ws => {
    if (ws.readyState === WebSocket.OPEN) {
      ws.close();
    }
  });
  
  // 关闭服务器
  server.close(() => {
    console.log('服务器已关闭');
    process.exit(0);
  });
});